package com.PVZ.engine.map.level;

import com.PVZ.engine.Stage;
import com.PVZ.engine.factory.ZombieFactory;
import com.PVZ.engine.map.GameMap;
import com.PVZ.model.emuns.MoveType;
import com.PVZ.model.emuns.ZombieType;
import com.PVZ.model.zombie.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.*;

/**
 * Created by @Author: kabuda on @Date: 2021/5/18 22:18
 * <p>
 * 本关有两个拿旗僵尸  三个铁桶僵尸  十三个帽子僵尸   三十二个普通僵尸
 */


@NoArgsConstructor
public class Level_1 extends Level {
    public static int a, b, c, d, e, f;

    /**
     * 剩余僵尸数量
     */
    int leftZombieNum;

    /**
     * 僵尸进攻的波次及时间
     */
    private List<Long> zombieAttackTimes;

    public Level_1(String name, String bgm, GameMap gameMap) {

        this.name = name;
        this.bgm = bgm;
        this.gameMap = gameMap;

        this.getZombieFactory().getAllZombieHashMap().put(ZombieType.FlagZombie, 999);
        this.getZombieFactory().getAllZombieHashMap().put(ZombieType.NormalZombie, 999);
        this.getZombieFactory().getAllZombieHashMap().put(ZombieType.ConeheadZombie, 999);
        this.getZombieFactory().getAllZombieHashMap().put(ZombieType.BucketZombie, 999);
        this.getZombieFactory().getAllZombieHashMap().put(ZombieType.PaperZombie, 999);
        this.getZombieFactory().getAllZombieHashMap().put(ZombieType.FootballZombie, 999);

        HashMap<ZombieType, Integer> allZombieHashMap = this.getZombieFactory().getAllZombieHashMap();


        //计算僵尸总数量
        int zombieNum = 0;
        for (Map.Entry<ZombieType, Integer> zombieEntry : allZombieHashMap.entrySet()) {
            zombieNum += zombieEntry.getValue();
        }
        this.getZombieFactory().setAllZombieNum(zombieNum);
        leftZombieNum = zombieNum;
    }

    @Override
    public void generateZombies(int gamePlayTime) {
        List<Zombie> allZombieList = getZombieFactory().getAllZombieList();
        long time=this.getLevelTime();


        if (time>=gamePlayTime&&leftZombieNum>0&&time<gamePlayTime+200){
            //第一波团战节奏
            //举旗僵尸 即每次大波僵尸来袭  本游戏共有两波  后面还要加判断场内是否还存在僵尸
            if(time %(gamePlayTime+90)==0){
                //后面添加判断 是否还存在活的僵尸 如果存在则将时间卡住
                if(false){

                }else{
                    generateZombie(allZombieList, ZombieType.FlagZombie);
                    leftZombieNum--;

                }
            }
            //向第一波过度僵尸
            //该僵尸持续到游戏结束
            if (time %15==gamePlayTime){
                generateZombie(allZombieList, ZombieType.NormalZombie);
                leftZombieNum--;
            }

            if(time >(gamePlayTime+30)&& time %10==gamePlayTime){
                int generateNum = (int) (Math.random() * 2);
                if (generateNum==0) {
                    generateZombie(allZombieList, ZombieType.NormalZombie);
                }else {
                    generateZombie(allZombieList, ZombieType.ConeheadZombie);
                }
                leftZombieNum--;
            }
            //第一波团战僵尸群
            if (gamePlayTime+90<= time && time <gamePlayTime+110){
                if (time %2==0){
                    generateZombie(allZombieList, ZombieType.NormalZombie);
                    leftZombieNum--;
                }
                if (time %5==0){
                    generateZombie(allZombieList, ZombieType.ConeheadZombie);
                    leftZombieNum--;
                }
                if (time %7==0){
                    generateZombie(allZombieList, ZombieType.PaperZombie);
                    leftZombieNum--;
                }
            }
            //第一波团后面加入读报僵尸
            if (time >gamePlayTime+90&& time %15==0){
                int generateNum = (int) (Math.random() * 2);
                if (generateNum==0) {
                    generateZombie(allZombieList, ZombieType.PaperZombie);
                }else {
                    generateZombie(allZombieList, ZombieType.ConeheadZombie);
                }
                leftZombieNum--;
            }
            //第二波团战僵尸群
            if (gamePlayTime+180<= time){
                if (time %2==0){
                    generateZombie(allZombieList, ZombieType.NormalZombie);
                    leftZombieNum--;
                }
                if (time %5==0){
                    generateZombie(allZombieList, ZombieType.ConeheadZombie);
                    leftZombieNum--;
                }
                if (time%6==0){
                    generateZombie(allZombieList, ZombieType.PaperZombie);
                    leftZombieNum--;
                }
                if(time %8==0){
                    generateZombie(allZombieList, ZombieType.FootballZombie);
                    leftZombieNum--;
                }
            }

        }


    }


    /**
     * 生成僵尸(生成到zombieList中)
     *
     * @param zombieList 僵尸总列表
     * @param zombieType 僵尸类型
     */
    public void generateZombie(List<Zombie> zombieList, ZombieType zombieType) {
        HashMap<ZombieType, Integer> allZombieHashMap = getZombieFactory().getAllZombieHashMap();
        Zombie zombie;
        switch (zombieType) {
            case NormalZombie:
                zombie = new NormalZombie((int) (Math.random() * 5), 10, MoveType.Left);

                break;
            case BucketZombie:
                zombie = new BucketZombie((int) (Math.random() * 5), 10, MoveType.Left);

                break;
            case ConeheadZombie:
                zombie = new ConeheadZombie((int) (Math.random() * 5), 10, MoveType.Left);

                break;
            case FlagZombie:
                zombie = new FlagZombie((int) (Math.random() * 5), 10, MoveType.Left);

                break;
            case FootballZombie:
                zombie = new FootballZombie((int) (Math.random() * 5), 10, MoveType.Left);

                break;
            case PaperZombie:
                zombie = new PaperZombie((int) (Math.random() * 5), 10, MoveType.Left);

                break;
            default:
                return;
        }

        //将僵尸添加到僵尸列表中
        zombieList.add(zombie);

    }

    // 有波次的
    // @Override
    // public void generateZombies(){
    //     HashMap<ZombieType, Integer> allZombieHashMap = this.getZombieFactory().getAllZombieHashMap();
    //     List<Zombie> allZombieList = this.getZombieFactory().getAllZombieList();
    //
//         if (this.getLevelTime()>TENSEC&&this.getAllZombieNum()>0){
//             //第一波团战节奏
//             //举旗僵尸 即每次大波僵尸来袭  本游戏共有两波  后面还要加判断场内是否还存在僵尸
//             if(this.getLevelTime()%(MIN+FALFMIN)==0){
//                 //后面添加判断 是否还存在活的僵尸 如果存在则将时间卡住
//                 if(false){
//
//                 }else{
//                     allZombieList.add(new FlagZombie((int)(Math.random()*5),10,MoveType.Left));
//                     allZombieHashMap.put(ZombieType.FlagZombie,allZombieHashMap.get(ZombieType.FlagZombie)-1);
//                     this.setAllZombieNum(this.getAllZombieNum()-1);
//
//                 }
//             }
//             //向第一波过度僵尸
//               //该僵尸持续到游戏结束
//             if (this.getLevelTime()%15==0){
//                 allZombieList.add(new NormalZombie((int)(Math.random()*5),12,MoveType.Left));
//                 allZombieHashMap.put(ZombieType.NormalZombie,allZombieHashMap.get(ZombieType.NormalZombie)-1);
//                 this.setAllZombieNum(this.getAllZombieNum()-1);
//                 System.out.println(++a+"普通僵尸");
//             }
//             if(this.getLevelTime()>30&&this.getLevelTime()%10==0){
//                 allZombieList.add(new NormalZombie((int)(Math.random()*5),12,MoveType.Left));
//                 allZombieHashMap.put(ZombieType.NormalZombie,allZombieHashMap.get(ZombieType.NormalZombie)-1);
//                 this.setAllZombieNum(this.getAllZombieNum()-1);
//                 System.out.println(++a+"普通僵尸");
//             }
//             //第一波团战僵尸群
//             if (MIN+FALFMIN<=this.getLevelTime()&&this.getLevelTime()<MIN*2-TENSEC){
//                 if (this.getLevelTime()%2==0){
//                     allZombieList.add(new NormalZombie((int)(Math.random()*5),(int)(Math.random()*2)+11,MoveType.Left));
//                     allZombieHashMap.put(ZombieType.NormalZombie,allZombieHashMap.get(ZombieType.NormalZombie)-1);
//                     this.setAllZombieNum(this.getAllZombieNum()-1);
//                     System.out.println(++a+"普通僵尸");//10
//                 }
//                 if (this.getLevelTime()%5==0){
//                     allZombieList.add(new ConeheadZombie((int)(Math.random()*5),(int)(Math.random()*2)+11,MoveType.Left));
//                     allZombieHashMap.put(ZombieType.ConeheadZombie,allZombieHashMap.get(ZombieType.ConeheadZombie)-1);
//                     this.setAllZombieNum(this.getAllZombieNum()-1);
//                     System.out.println(++b+"路障僵尸");//4
//                 }
//             }
//             //第一波团后面加入路障僵尸
//             if (this.getLevelTime()>MIN+FALFMIN&&this.getLevelTime()%15==0){
//                 allZombieList.add(new ConeheadZombie((int)(Math.random()*5),12,MoveType.Left));
//                 allZombieHashMap.put(ZombieType.ConeheadZombie,allZombieHashMap.get(ZombieType.ConeheadZombie)-1);
//                 this.setAllZombieNum(this.getAllZombieNum()-1);
//                 System.out.println(++b+"路障僵尸");
//             }
//             //第二波团战僵尸群
//             if (3*MIN<=this.getLevelTime()&&this.getLevelTime()<MIN*3+TENSEC*2){
//                 if (this.getLevelTime()%2==0){
//                     allZombieList.add(new NormalZombie((int)(Math.random()*5),(int)(Math.random()*2)+11,MoveType.Left));
//                     allZombieHashMap.put(ZombieType.NormalZombie,allZombieHashMap.get(ZombieType.NormalZombie)-1);
//                     this.setAllZombieNum(this.getAllZombieNum()-1);
//                     System.out.println(++a+"普通僵尸");//10
//                 }
//                 if (this.getLevelTime()%5==0){
//                     allZombieList.add(new ConeheadZombie((int)(Math.random()*5),(int)(Math.random()*2)+11,MoveType.Left));
//                     allZombieHashMap.put(ZombieType.ConeheadZombie,allZombieHashMap.get(ZombieType.ConeheadZombie)-1);
//                     this.setAllZombieNum(this.getAllZombieNum()-1);
//                     System.out.println(++b+"路障僵尸");//4
//                 }
//                 if(this.getLevelTime()%6==0){
//                     allZombieList.add(new BucketZombie((int)(Math.random()*5),(int)(Math.random()*2)+11,MoveType.Left));
//                     allZombieHashMap.put(ZombieType.BucketZombie,allZombieHashMap.get(ZombieType.BucketZombie)-1);
//                     this.setAllZombieNum(this.getAllZombieNum()-1);
//                     System.out.println("铁铁");//4
//                 }
//             }
//
//         }
    //
    //     this.getZombieFactory().setAllZombieHashMap(allZombieHashMap);
    //     this.getZombieFactory().setAllZombieList(allZombieList);
    // }


}
